home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / system / source / log.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-11-22  |  4.3 KB  |  162 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    System library component
  3. //    Copyright (C) 1998-2004 Avery Lee, All Rights Reserved.
  4. //
  5. //    Beginning with 1.6.0, the VirtualDub system library is licensed
  6. //    differently than the remainder of VirtualDub.  This particular file is
  7. //    thus licensed as follows (the "zlib" license):
  8. //
  9. //    This software is provided 'as-is', without any express or implied
  10. //    warranty.  In no event will the authors be held liable for any
  11. //    damages arising from the use of this software.
  12. //
  13. //    Permission is granted to anyone to use this software for any purpose,
  14. //    including commercial applications, and to alter it and redistribute it
  15. //    freely, subject to the following restrictions:
  16. //
  17. //    1.    The origin of this software must not be misrepresented; you must
  18. //        not claim that you wrote the original software. If you use this
  19. //        software in a product, an acknowledgment in the product
  20. //        documentation would be appreciated but is not required.
  21. //    2.    Altered source versions must be plainly marked as such, and must
  22. //        not be misrepresented as being the original software.
  23. //    3.    This notice may not be removed or altered from any source
  24. //        distribution.
  25.  
  26. #include "stdafx.h"
  27. #include <vd2/system/vdtypes.h>
  28. #include <list>
  29. #include <utility>
  30. #include <vd2/system/log.h>
  31. #include <vd2/system/thread.h>
  32. #include <vd2/system/VDString.h>
  33.  
  34. namespace {
  35.     wchar_t        g_log[16384];            // 32K log
  36.     int            g_logHead, g_logTail;
  37.     VDCriticalSection    g_csLog;
  38.  
  39.     typedef std::list<std::pair<IVDLogger *, VDThreadID> > tVDLoggers;
  40.     tVDLoggers g_loggers;
  41. }
  42.  
  43. void VDLog(int severity, const VDStringW& s) {
  44.     int strSize = s.size() + 1;
  45.  
  46.     if (strSize >= 16384) {
  47.         VDASSERT(false);
  48.         return;
  49.     }
  50.  
  51.     vdsynchronized(g_csLog) {
  52.         for(;;) {
  53.             int currentSize = (g_logTail - g_logHead) & 16383;
  54.  
  55.             if (currentSize + strSize < 16384)    // NOTE: This means that the last byte in the ring buffer can never be used.
  56.                 break;
  57.  
  58.             while(g_log[g_logHead++ & 16383])
  59.                 ;
  60.  
  61.             g_logHead &= 16383;
  62.         }
  63.  
  64.         const wchar_t *ps = s.data();
  65.  
  66.         g_log[g_logTail++] = severity;
  67.  
  68.         for(int i=1; i<strSize; ++i)
  69.             g_log[g_logTail++ & 16383] = *ps++;
  70.  
  71.         g_log[g_logTail++ & 16383] = 0;
  72.  
  73.         g_logTail &= 16383;
  74.  
  75.         VDThreadID currentThread = VDGetCurrentThreadID();
  76.         for(tVDLoggers::const_iterator it(g_loggers.begin()), itEnd(g_loggers.end()); it!=itEnd; ++it) {
  77.             if (!(*it).second || currentThread == (*it).second)
  78.                 (*it).first->AddLogEntry(severity, s);
  79.         }
  80.     }
  81. }
  82.  
  83. void VDAttachLogger(IVDLogger *pLogger, bool bThisThreadOnly, bool bReplayLog) {
  84.     vdsynchronized(g_csLog) {
  85.         g_loggers.push_back(tVDLoggers::value_type(pLogger, bThisThreadOnly ? VDGetCurrentThreadID() : 0));
  86.  
  87.         if (bReplayLog) {
  88.             int idx = g_logHead;
  89.  
  90.             while(idx != g_logTail) {
  91.                 int severity = g_log[idx++];
  92.                 int headidx = idx;
  93.  
  94.                 idx &= 16383;
  95.  
  96.                 for(;;) {
  97.                     wchar_t c = g_log[idx];
  98.  
  99.                     idx = (idx+1) & 16383;
  100.  
  101.                     if (!c)
  102.                         break;
  103.                 }
  104.  
  105.                 if (idx > headidx) {
  106.                     pLogger->AddLogEntry(severity, VDStringW(g_log + headidx, idx-headidx-1));
  107.                 } else {
  108.                     VDStringW t(idx+16383-headidx);
  109.  
  110.                     std::copy(g_log + headidx, g_log + 16384, const_cast<wchar_t *>(t.data()));
  111.                     std::copy(g_log, g_log + idx - 1, const_cast<wchar_t *>(t.data() + (16384 - headidx)));
  112.                     pLogger->AddLogEntry(severity, t);
  113.                 }
  114.             }
  115.         }
  116.     }
  117. }
  118.  
  119. void VDDetachLogger(IVDLogger *pLogger) {
  120.     vdsynchronized(g_csLog) {
  121.         for(tVDLoggers::iterator it(g_loggers.begin()), itEnd(g_loggers.end()); it!=itEnd; ++it) {
  122.             if (pLogger == (*it).first) {
  123.                 g_loggers.erase(it);
  124.                 break;
  125.             }
  126.         }
  127.     }
  128. }
  129.  
  130. ///////////////////////////////////////////////////////////////////////////
  131. //
  132. //    autologger
  133. //
  134. ///////////////////////////////////////////////////////////////////////////
  135.  
  136. VDAutoLogger::VDAutoLogger(int min_severity)
  137.     : mbAttached(true)
  138.     , mMinSeverity(min_severity)
  139. {
  140.     VDAttachLogger(this, false, false);
  141. }
  142.  
  143. VDAutoLogger::~VDAutoLogger() {
  144.     if (mbAttached)
  145.         VDDetachLogger(this);
  146. }
  147.  
  148. void VDAutoLogger::AddLogEntry(int severity, const VDStringW& s) {
  149.     if (severity >= mMinSeverity)
  150.         mEntries.push_back(Entry(severity, s));
  151. }
  152.  
  153. const VDAutoLogger::tEntries& VDAutoLogger::GetEntries() {
  154.     if (mbAttached) {
  155.         VDDetachLogger(this);
  156.         mbAttached = false;
  157.     }
  158.  
  159.     return mEntries;
  160. }
  161.  
  162.